home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcr / pcr4_4.lha / DIST / debugnub / RDTProcs.c < prev    next >
C/C++ Source or Header  |  1991-06-17  |  19KB  |  730 lines
  1. /* begincopyright
  2.   Copyright (c) 1988 Xerox Corporation. All rights reserved.
  3.   Use and copying of this software and preparation of derivative works based
  4.   upon this software are permitted. Any distribution of this software or
  5.   derivative works must comply with all applicable United States export
  6.   control laws. This software is made available AS IS, and Xerox Corporation
  7.   makes no warranty about the software, its performance or its conformity to
  8.   any specification. Any person obtaining a copy of this software is requested
  9.   to send their name and post office or electronic mail address to:
  10.     PCR Coordinator
  11.     Xerox PARC
  12.     3333 Coyote Hill Rd.
  13.     Palo Alto, CA 94304
  14.   endcopyright */
  15.  
  16. /*
  17.  * RDTProcs.c
  18.  *
  19.  * Stubs for remote debug tool.
  20.  *
  21.  * Demers, February 20, 1990 9:19:13 am PST
  22.  */
  23.  
  24. #include "xr/BasicTypes.h"
  25. #include "xr/Errno.h"
  26. #include "xr/CirioNubTypes.h"
  27. #include "xr/CirioNubProtocol.h"
  28. #include "xr/CirioNubProcs.h"
  29. #include "xr/RDTRuntime.h"
  30. #include "xr/RDTProcs.h"
  31.  
  32.  
  33. #if (( RDT_PROCS_VERSION ) != ( CIRIO_NUB_PROCS_VERSION ))
  34.     --> RDT_PROCS_VERSION != CIRIO_NUB_PROCS_VERSION <--
  35. #endif
  36.  
  37. static char *
  38. RDT_CopyStr(str)
  39.     char *str;
  40. {
  41.     char *newStr = NIL;
  42.  
  43.     if( str != NIL ) {
  44.         int len1 = 1 + strlen(str);
  45.         newStr = (char *)malloc(len1);
  46.         bcopy(str, newStr, len1);
  47.     }
  48.     return newStr;
  49. }
  50.  
  51. #define RDT_FREE(p) if(((char *)(p)) != NIL) { free( ((char *)(p)) ); }
  52.  
  53.  
  54. int
  55. RDT_Null(desiredVersion, resultVersionPtr)
  56.     unsigned desiredVersion;
  57.     unsigned *resultVersionPtr;
  58. {
  59.     CirioNubRetCode rc;
  60.     unsigned argc;
  61.     unsigned buf[64];
  62.  
  63.     desiredVersion &= 0xffff; /* procs version only */
  64.     rc = RDT_PutCard32(
  65.             CIRIO_NUB_VERSION(CIRIO_NUB_PROTOCOL_VERSION, desiredVersion) );
  66.     if( rc == cnrc_ok ) {
  67.         rc = RDT_SendCall(CirioNubProcID_Null);
  68.     }
  69.     if( rc == cnrc_ok ) {
  70.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  71.     }
  72.     if( rc == cnrc_ok ) {
  73.         if( argc == 1 ) {
  74.             (*resultVersionPtr) =
  75.                     ((unsigned)(buf[0])) & 0xffff; /* procs version only */
  76.         } else {
  77.             rc = cnrc_badArgs;
  78.         }
  79.     }
  80.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  81. }
  82.  
  83.  
  84. int
  85. RDT_WaitSig(timeoutMsec, dbStatP)
  86.     unsigned timeoutMsec;
  87.     int *dbStatP;
  88. {
  89.     CirioNubRetCode rc;
  90.     bool gotSig;
  91.     unsigned argc;
  92.     unsigned buf[64];
  93.  
  94.     rc = RDT_PutCard32(timeoutMsec);
  95.     if( rc == cnrc_ok ) {
  96.         rc = RDT_SendCall(CirioNubProcID_WaitSig);
  97.     }
  98.     if( rc == cnrc_ok ) {
  99.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  100.     }
  101.     if( rc == cnrc_ok ) {
  102.         if( argc == 2 ) {
  103.             gotSig = ((bool)(buf[0]));
  104.             (*dbStatP) = ((int)(buf[1]));
  105.         } else {
  106.             rc = cnrc_badArgs;
  107.         }
  108.     }
  109.     return ( (rc == cnrc_ok) ? (gotSig ? 0 : 1) : (-1) );
  110. }
  111.  
  112. int /* -err */
  113. RDT_SetDBStat (dbStat, timeoutMsec)
  114.     int dbStat;
  115.     unsigned timeoutMsec;
  116. {
  117.     CirioNubRetCode rc;
  118.     int ans;
  119.     unsigned argc;
  120.     unsigned buf[64];
  121.  
  122.     rc = RDT_PutInt32(dbStat);
  123.     if( rc == cnrc_ok ) {
  124.         rc = RDT_PutCard32(timeoutMsec);
  125.     }
  126.     if( rc == cnrc_ok ) {
  127.         rc = RDT_SendCall(CirioNubProcID_SetDBStat);
  128.     }
  129.     if( rc == cnrc_ok ) {
  130.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  131.     }
  132.     if( rc == cnrc_ok ) {
  133.         if( argc == 1 ) {
  134.             ans = ((int)(buf[0]));
  135.         } else {
  136.             rc = cnrc_badArgs;
  137.         }
  138.     }
  139.     return ( (rc == cnrc_ok) ? ((ans == 0) ? 0 : 1) : (-1) );
  140. }
  141.  
  142.  
  143.  
  144. static int
  145. RDT_GetBlock(addr, nBytes, clientBuf, getProcID)
  146.     unsigned addr;
  147.     unsigned nBytes;
  148.     char *clientBuf;
  149.     unsigned getProcID;
  150. {
  151.     CirioNubRetCode rc;
  152.     int ans;
  153.     unsigned argc;
  154.     unsigned buf[2048];
  155.  
  156.     rc = RDT_PutCard32(addr);
  157.     if( rc == cnrc_ok ) {
  158.         rc = RDT_PutCard32(nBytes);
  159.     }
  160.     if( rc == cnrc_ok ) switch(getProcID) {
  161.         case CirioNubProcID_GetBytes:
  162.         case CirioNubProcID_GetWords16:
  163.         case CirioNubProcID_GetWords32:
  164.             break;
  165.         default:
  166.             rc = cnrc_protocol;
  167.             break;
  168.     }
  169.     if( rc == cnrc_ok ) {
  170.         rc = RDT_SendCall(getProcID);
  171.     }
  172.     if( rc == cnrc_ok ) {
  173.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  174.     }
  175.     if( rc == cnrc_ok ) {
  176.         if( argc == 2 ) {
  177.             ans = ((int)(buf[0]));
  178.             if( ans > 0 ) {
  179.                 (void) bcopy( ((char *)(buf[1])), clientBuf, ans );
  180.             }
  181.         } else {
  182.             rc = cnrc_badArgs;
  183.         }
  184.     }
  185.     return ( (rc == cnrc_ok) ? ans : (-1) );
  186. }
  187.  
  188. int /* bytesRead or -err */
  189. RDT_GetBytes(addr, nBytes, clientBuf)
  190.     unsigned addr;
  191.     unsigned nBytes;
  192.     char *clientBuf;
  193. {
  194.     return RDT_GetBlock( addr, nBytes, clientBuf,
  195.             CirioNubProcID_GetBytes );
  196. }
  197.  
  198. int /* bytesRead or -err */
  199. RDT_GetWords16(addr, nBytes, clientBuf)
  200.     unsigned addr;
  201.     unsigned nBytes;
  202.     unsigned short *clientBuf;
  203. {
  204.     return RDT_GetBlock( addr, nBytes, ((char *)(clientBuf)),
  205.             CirioNubProcID_GetWords16 );
  206. }
  207.  
  208. int /* bytesRead or -err */
  209. RDT_GetWords32(addr, nBytes, clientBuf)
  210.     unsigned addr;
  211.     unsigned nBytes;
  212.     unsigned *clientBuf;
  213. {
  214.     return RDT_GetBlock( addr, nBytes, ((char *)(clientBuf)),
  215.             CirioNubProcID_GetWords32 );
  216. }
  217.  
  218.  
  219.  
  220. static int /* bytesPut or -err */
  221. RDT_PutBlock(addr, nBytes, clientBuf, putProcID)
  222.     unsigned addr;
  223.     unsigned nBytes;
  224.     char *clientBuf;
  225.     unsigned putProcID;
  226. {
  227.     CirioNubRetCode rc;
  228.     int ans = -1;
  229.     unsigned argc;
  230.     unsigned buf[64];
  231.  
  232.     rc = RDT_PutCard32(addr);
  233.     if( rc == cnrc_ok ) switch(putProcID) {
  234.         case CirioNubProcID_PutBytes:
  235.             rc = RDT_PutBlock8(clientBuf, nBytes);
  236.             break;
  237.         case CirioNubProcID_PutWords16:
  238.             rc = RDT_PutBlock16(((unsigned short *)(clientBuf)), nBytes);
  239.             break;
  240.         case CirioNubProcID_PutWords32:
  241.             rc = RDT_PutBlock32(((unsigned *)(clientBuf)), nBytes);
  242.             break;
  243.         default:
  244.             rc = cnrc_protocol;
  245.             break;
  246.     }
  247.     if( rc == cnrc_ok ) {
  248.         rc = RDT_SendCall(putProcID);
  249.     }
  250.     if( rc == cnrc_ok ) {
  251.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  252.     }
  253.     if( rc == cnrc_ok ) {
  254.         if( argc != 1 ) rc = cnrc_badArgs;
  255.     }
  256.     if( rc == cnrc_ok ) {
  257.         if( (ans = ((int)(buf[0]))) == 0 ) ans = nBytes;
  258.     }
  259.     return ans;
  260. }
  261.  
  262.  
  263. int /* bytesPut or -err */
  264. RDT_PutBytes(addr, nBytes, clientBuf)
  265.     unsigned addr;
  266.     unsigned nBytes;
  267.     char *clientBuf;
  268. {
  269.     return RDT_PutBlock( addr, nBytes, clientBuf,
  270.             CirioNubProcID_PutBytes );
  271. }
  272.  
  273.  
  274. int /* bytesPut or -err */
  275. RDT_PutWords16(addr, nBytes, clientBuf)
  276.     unsigned addr;
  277.     unsigned nBytes;
  278.     unsigned short *clientBuf;
  279. {
  280.     return RDT_PutBlock( addr, nBytes, ((char *)(clientBuf)),
  281.             CirioNubProcID_PutWords16 );
  282. }
  283.  
  284.  
  285. int /* bytesPut or -err */
  286. RDT_PutWords32(addr, nBytes, clientBuf)
  287.     unsigned addr;
  288.     unsigned nBytes;
  289.     unsigned *clientBuf;
  290. {
  291.     return RDT_PutBlock( addr, nBytes, ((char *)(clientBuf)),
  292.             CirioNubProcID_PutWords32 );
  293. }
  294.  
  295.  
  296.  
  297. int /* -err */
  298. RDT_GetThread(index, dataPtr)
  299.     int index;
  300.     CirioNubThreadData *dataPtr;
  301. {
  302.     CirioNubRetCode rc;
  303.     int ans;
  304.     unsigned argc;
  305.     CirioNubThreadData fromData, toData;
  306.     unsigned buf[1024];
  307.  
  308.     if( index > 0 ) index = (-index);
  309.     rc = RDT_PutInt32(index);
  310.     if( rc == cnrc_ok ) {
  311.         rc = RDT_PutInt32(0);
  312.     }
  313.     if( rc == cnrc_ok ) {
  314.         rc = RDT_SendCall(CirioNubProcID_GetThreads);
  315.     }
  316.     if( rc == cnrc_ok ) {
  317.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  318.     }
  319.     if( rc == cnrc_ok ) {
  320.         if( argc == 2 ) {
  321.             switch( ((unsigned)(buf[0])) ) {
  322.                 case 0:
  323.                     ans = 1;
  324.                     break;
  325.                 case (sizeof (**dataPtr)):
  326.                     fromData = ((CirioNubThreadData)(buf[1]));
  327.                     toData = ( (CirioNubThreadData)
  328.                            (malloc( sizeof (*fromData) )) );
  329.                     (void) bcopy( fromData, toData, (sizeof (*fromData)) );
  330.                     /* no strings to copy */
  331.                     *dataPtr = toData;
  332.                     ans = 0;
  333.                     break;
  334.                 default:
  335.                     rc = cnrc_badArgs;
  336.                     break;
  337.             }
  338.         } else {
  339.             rc = cnrc_badArgs;
  340.         }
  341.     }
  342.     return ( (rc == cnrc_ok) ? ans : (-1) );
  343. }
  344.  
  345. void
  346. RDT_FreeThreadData(dataPtr)
  347.     CirioNubThreadData *dataPtr;
  348. {
  349.     RDT_FREE(*dataPtr);
  350.     *dataPtr = NIL;
  351. }
  352.  
  353. static CirioNubPCInfo /* NIL on failure */
  354. RDT_CopyPCInfoBuf(buf, argc, pos)
  355.     unsigned *buf;
  356.     unsigned argc;
  357.     unsigned pos;
  358. {
  359.     CirioNubPCInfo toInfo;
  360.  
  361.     if( argc < (pos+6) ) return NIL;
  362.     toInfo = ( (CirioNubPCInfo)(malloc( sizeof (*toInfo) )) );
  363.     toInfo->procName = RDT_CopyStr( ((char *)(buf[pos])) );  pos += 1;
  364.     toInfo->procSymID = ((unsigned)(buf[pos]));  pos += 1;
  365.     toInfo->fileName = RDT_CopyStr( ((char *)(buf[pos])) );  pos += 1;
  366.     toInfo->fileSeqNum = ((unsigned)(buf[pos]));  pos += 1;
  367.     toInfo->guessedEmbeddedFileName = RDT_CopyStr( ((char *)(buf[pos])) );
  368.             pos += 1;
  369.     toInfo->guessedEmbeddedFileSymID = ((unsigned)(buf[pos]));
  370.     return toInfo;
  371. }
  372.  
  373.  
  374. int /* -err */
  375. RDT_PCtoInfo (pc, infoPtr)
  376.     unsigned pc;
  377.     CirioNubPCInfo *infoPtr;
  378. {
  379.     CirioNubRetCode rc;
  380.     unsigned argc;
  381.     CirioNubPCInfo toInfo;
  382.     unsigned buf[1024];
  383.  
  384.     rc = RDT_PutCard32(pc);
  385.     if( rc == cnrc_ok ) {
  386.         rc = RDT_SendCall(CirioNubProcID_PCtoInfo);
  387.     }
  388.     if( rc == cnrc_ok ) {
  389.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  390.     }
  391.     if( rc == cnrc_ok ) {
  392.         if( argc == 6 ) {
  393.             (*infoPtr) = RDT_CopyPCInfoBuf(buf, argc, 0);
  394.             if( (*infoPtr) == NIL ) rc = cnrc_badArgs;
  395.         } else {
  396.             rc = cnrc_badArgs;
  397.         }
  398.     }
  399.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  400.  
  401. }
  402.  
  403.  
  404. void
  405. RDT_FreePCInfo(infoPtr)
  406.     CirioNubPCInfo *infoPtr;
  407. {
  408.     CirioNubPCInfo info;
  409.  
  410.     if( (info= *infoPtr) != NIL ) {
  411.         RDT_FREE(info->procName);
  412.         RDT_FREE(info->fileName);
  413.         RDT_FREE(info->guessedEmbeddedFileName);
  414.         free(info);
  415.     }
  416.     *infoPtr = NIL;
  417. } 
  418.  
  419.  
  420. int
  421. RDT_KillWorld()
  422. {
  423.     CirioNubRetCode rc;
  424.     unsigned argc;
  425.     unsigned buf[64];
  426.  
  427.     rc = RDT_SendCall(CirioNubProcID_KillWorld);
  428.     if( rc == cnrc_ok ) {
  429.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  430.     }
  431.     if( rc == cnrc_ok ) {
  432.         if( argc == 0 ) {
  433.             ;
  434.         } else {
  435.             rc = cnrc_badArgs;
  436.         }
  437.     }
  438.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  439. }
  440.  
  441.  
  442. int /* -err */
  443. RDT_IssueThreadCommand(threadIndex, setFreeze, freeze, setMsg, msg)
  444.     int threadIndex;
  445.     bool setFreeze;
  446.     bool freeze;
  447.     bool setMsg;
  448.     int msg;
  449. {
  450.     CirioNubRetCode rc;
  451.     int ans;
  452.     unsigned argc;
  453.     unsigned buf[128];
  454.  
  455.     rc = RDT_PutInt32(threadIndex);
  456.     if( rc == cnrc_ok ) {
  457.         rc = RDT_PutInt32(((int)(setFreeze)));
  458.     }
  459.     if( rc == cnrc_ok ) {
  460.         rc = RDT_PutInt32(((int)(freeze)));
  461.     }
  462.     if( rc == cnrc_ok ) {
  463.         rc = RDT_PutInt32(((int)(setMsg)));
  464.     }
  465.     if( rc == cnrc_ok ) {
  466.         rc = RDT_PutInt32(msg);
  467.     }
  468.     if( rc == cnrc_ok ) {
  469.         rc = RDT_SendCall(CirioNubProcID_IssueThreadCommand);
  470.     }
  471.     if( rc == cnrc_ok ) {
  472.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  473.     }
  474.     if( rc == cnrc_ok ) {
  475.         if( argc == 1 ) {
  476.             ans = ((int)(buf[0]));
  477.         } else {
  478.             rc = cnrc_badArgs;
  479.         }
  480.     }
  481.     return ( (rc == cnrc_ok) ? ans : (-1) );
  482. }
  483.  
  484. int /* 0, 1, -err */
  485. RDT_GetDBStat (timeoutMsec, indexPtr, dbStatPtr)
  486.     unsigned timeoutMsec;
  487.     int *indexPtr;
  488.     int *dbStatPtr;
  489. {
  490.     CirioNubRetCode rc;
  491.     unsigned argc;
  492.     unsigned buf[128];
  493.  
  494.     rc = RDT_PutInt32(*dbStatPtr);
  495.     if( rc == cnrc_ok ) {
  496.         rc = RDT_PutInt32(*indexPtr);
  497.     }
  498.     if( rc == cnrc_ok ) {
  499.         rc = RDT_PutCard32(timeoutMsec);
  500.     }
  501.     if( rc == cnrc_ok ) {
  502.         rc = RDT_SendCall(CirioNubProcID_GetDBStat);
  503.     }
  504.     if( rc == cnrc_ok ) {
  505.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  506.     }
  507.     if( rc == cnrc_ok ) {
  508.         if( argc == 2 ) {
  509.             (*dbStatPtr) = ((int)(buf[0]));
  510.             (*indexPtr) = ((int)(buf[1]));
  511.         } else {
  512.             rc = cnrc_badArgs;
  513.         }
  514.     }
  515.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  516. }
  517.  
  518.  
  519. static CirioNubFileEntry /* NIL on failure */
  520. RDT_CopyFileEntryFromBuf(buf, argc, pos)
  521.     unsigned *buf;
  522.     unsigned argc;
  523.     unsigned pos;
  524. {
  525.     CirioNubFileEntry toFileEntry;
  526.  
  527.     if( argc < (pos+22) ) return NIL;
  528.     toFileEntry = ((CirioNubFileEntry)(malloc(sizeof (*toFileEntry) )));
  529.     toFileEntry->seqNum = ((unsigned)(buf[pos]));  pos += 1;
  530.     toFileEntry->commitPoint = ((bool)(buf[pos]));  pos += 1;
  531.     toFileEntry->fileName = RDT_CopyStr( ((char *)(buf[pos])) );  pos += 1;
  532.     toFileEntry->fOffset = ((unsigned)(buf[pos]));  pos += 1;
  533.     toFileEntry->fMagic = ((unsigned)(buf[pos]));  pos += 1;
  534.     toFileEntry->size = ((size_t)(buf[pos]));  pos += 1;
  535.     toFileEntry->mTime = ((time_t)(buf[pos]));  pos += 1;
  536.     toFileEntry->sMagic = ((unsigned)(buf[pos]));  pos += 1;
  537.     toFileEntry->stamp = ((XR_Pointer)(buf[pos]));  pos += 1;
  538.     toFileEntry->stampSize = ((unsigned)(buf[pos]));  pos += 1;
  539.     toFileEntry->readerData = ((XR_Pointer)(buf[pos]));  pos += 1;
  540.     toFileEntry->readerDataSize = ((unsigned)(buf[pos]));  pos += 1;
  541.     toFileEntry->patchReloc = ((XR_Pointer)(buf[pos]));  pos += 1;
  542.     toFileEntry->patchSize = ((unsigned)(buf[pos]));  pos += 1;
  543.     toFileEntry->textReloc = ((XR_Pointer)(buf[pos]));  pos += 1;
  544.     toFileEntry->textSize = ((unsigned)(buf[pos]));  pos += 1;
  545.     toFileEntry->dataReloc = ((XR_Pointer)(buf[pos]));  pos += 1;
  546.     toFileEntry->dataSize = ((unsigned)(buf[pos]));  pos += 1;
  547.     toFileEntry->bssReloc = ((XR_Pointer)(buf[pos]));  pos += 1;
  548.     toFileEntry->bssSize = ((unsigned)(buf[pos]));  pos += 1;
  549.     toFileEntry->commonReloc = ((XR_Pointer)(buf[pos]));  pos += 1;
  550.     toFileEntry->commonSize = ((unsigned)(buf[pos]));  pos += 1;
  551.     return toFileEntry;
  552. }
  553.  
  554. int /* -err */
  555. RDT_GetFileEntry(seqNum, fileEntryPtr)
  556.     unsigned seqNum;
  557.     CirioNubFileEntry *fileEntryPtr;
  558.  
  559. {
  560.     CirioNubRetCode rc;
  561.     int ans;
  562.     CirioNubFileEntry toFileEntry;
  563.     unsigned argc;
  564.     unsigned buf[1024];
  565.  
  566.     rc = RDT_PutCard32(seqNum);
  567.     if( rc == cnrc_ok ) {
  568.         rc = RDT_SendCall(CirioNubProcID_GetFileEntry);
  569.     }
  570.     if( rc == cnrc_ok ) {
  571.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  572.     }
  573.     if( rc == cnrc_ok ) {
  574.         (*fileEntryPtr) = RDT_CopyFileEntryFromBuf(buf, argc, 0);
  575.         if( (*fileEntryPtr) != NIL ) {
  576.             ;
  577.         } else {
  578.             rc = cnrc_badArgs;
  579.         }
  580.     }
  581.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  582. }
  583.  
  584.  
  585. void
  586. RDT_FreeFileEntry(fileEntryPtr)
  587.     CirioNubFileEntry *fileEntryPtr;
  588. {
  589.     CirioNubFileEntry fe;
  590.  
  591.     if( (fe = *fileEntryPtr) != NIL ) {
  592.         RDT_FREE(fe->fileName);
  593.         free(fe);
  594.         *fileEntryPtr = NIL;
  595.     }
  596. }
  597.  
  598.  
  599. static CirioNubSymEntry
  600. RDT_CopySymEntryFromBuf(buf, argc, pos)
  601.     unsigned *buf;
  602.     unsigned argc;
  603.     unsigned pos;
  604. {
  605.     CirioNubSymEntry toSymEntry;
  606.  
  607.     if( argc < (pos+6) ) return NIL;
  608.     toSymEntry = ((CirioNubSymEntry)(malloc(sizeof (*toSymEntry) )));
  609.     toSymEntry->symID = ((unsigned)(buf[pos]));  pos += 1;
  610.     toSymEntry->name = RDT_CopyStr( ((char *)(buf[pos])) );  pos += 1;
  611.     toSymEntry->type = ((unsigned)(buf[pos]));  pos += 1;
  612.     toSymEntry->value = ((unsigned)(buf[pos]));  pos += 1;
  613.     toSymEntry->size = ((unsigned)(buf[pos]));  pos += 1;
  614.     toSymEntry->fileSeqNum = ((unsigned)(buf[pos]));  pos += 1;
  615.     return toSymEntry;
  616. }
  617.  
  618.  
  619. int /* -err */
  620. RDT_GetMatchingSymEntryByName( symID, pattern, caseSensitive, wantedTypes, 
  621.         ignoredClasses, numToSkip, symEntryPtr )
  622.     unsigned symID;
  623.     char *pattern;
  624.     bool caseSensitive;
  625.     unsigned wantedTypes;
  626.     unsigned ignoredClasses;
  627.     int numToSkip;
  628.     CirioNubSymEntry *symEntryPtr;
  629. {
  630.     CirioNubRetCode rc;
  631.     unsigned argc;
  632.     unsigned buf[2048];
  633.  
  634.     rc = RDT_PutCard32(symID);
  635.     if( rc == cnrc_ok ) {
  636.         rc = RDT_PutString(pattern);
  637.     }
  638.     if( rc == cnrc_ok ) {
  639.         rc = RDT_PutInt32(((int)(caseSensitive)));
  640.     }
  641.     if( rc == cnrc_ok ) {
  642.         rc = RDT_PutCard32(wantedTypes);
  643.     }
  644.     if( rc == cnrc_ok ) {
  645.         rc = RDT_PutCard32(ignoredClasses);
  646.     }
  647.     if( rc == cnrc_ok ) {
  648.         rc = RDT_PutInt32(numToSkip);
  649.     }
  650.     if( rc == cnrc_ok ) {
  651.         rc = RDT_SendCall(CirioNubProcID_GetMatchingSymEntryByName);
  652.     }
  653.     if( rc == cnrc_ok ) {
  654.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  655.     }
  656.     if( rc == cnrc_ok ) {
  657.         if( argc >  0 ) {
  658.             if( ((int)(buf[0])) == 0 ) {
  659.                 (*symEntryPtr) = RDT_CopySymEntryFromBuf(buf, argc, 0);
  660.                 if( (*symEntryPtr) != NIL ) {
  661.                     ;
  662.                 } else {
  663.                     rc = cnrc_badArgs;
  664.                 }
  665.             } else {
  666.                 (*symEntryPtr) = NIL;
  667.             }
  668.         } else {
  669.             rc = cnrc_badArgs;
  670.         }
  671.     }
  672.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  673. }
  674.  
  675.  
  676. int /* -err */
  677. RDT_GetMatchingSymEntryByValue( symID, val, wantedTypes, ignoredClasses,
  678.         numToSkip, symEntryPtr )
  679.     unsigned symID;
  680.     unsigned val;
  681.     unsigned wantedTypes;
  682.     unsigned ignoredClasses;
  683.     int numToSkip;
  684.     CirioNubSymEntry *symEntryPtr;
  685. {
  686.     CirioNubRetCode rc;
  687.     int ans;
  688.     CirioNubFileEntry toFileEntry;
  689.     unsigned argc;
  690.     unsigned buf[2048];
  691.  
  692.     rc = RDT_PutCard32(symID);
  693.     if( rc == cnrc_ok ) {
  694.         rc = RDT_PutCard32(val);
  695.     }
  696.     if( rc == cnrc_ok ) {
  697.         rc = RDT_PutCard32(wantedTypes);
  698.     }
  699.     if( rc == cnrc_ok ) {
  700.         rc = RDT_PutCard32(ignoredClasses);
  701.     }
  702.     if( rc == cnrc_ok ) {
  703.         rc = RDT_PutInt32(numToSkip);
  704.     }
  705.     if( rc == cnrc_ok ) {
  706.         rc = RDT_SendCall(CirioNubProcID_GetMatchingSymEntryByValue);
  707.     }
  708.     if( rc == cnrc_ok ) {
  709.         rc = RDT_ReadReply( buf, (sizeof buf), &argc );
  710.     }
  711.     if( rc == cnrc_ok ) {
  712.         if( argc >  0 ) {
  713.             if( ((int)(buf[0])) == 0 ) {
  714.                 (*symEntryPtr) = RDT_CopySymEntryFromBuf(buf, argc, 0);
  715.                 if( (*symEntryPtr) != NIL ) {
  716.                     ;
  717.                 } else {
  718.                     rc = cnrc_badArgs;
  719.                 }
  720.             } else {
  721.                 (*symEntryPtr) = NIL;
  722.             }
  723.         } else {
  724.             rc = cnrc_badArgs;
  725.         }
  726.     }
  727.     return ( (rc == cnrc_ok) ? 0 : (-1) );
  728. }
  729.  
  730.